using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("Player")]
	public class Player : Entity
	{
		public enum Side
		{
			NEUTRAL,
			FRIENDLY,
			OPPOSING
		}

		public bool m_waitingForHeroEntity => method_2<bool>("m_waitingForHeroEntity");

		public string m_name => method_4("m_name");

		public bool m_local => method_2<bool>("m_local");

		public Side m_side => method_2<Side>("m_side");

		public int m_cardBackId => method_2<int>("m_cardBackId");

		public ManaCounter m_manaCounter => method_3<ManaCounter>("m_manaCounter");

		public Entity m_hero => method_3<Entity>("m_hero");

		public Entity m_heroPower => method_3<Entity>("m_heroPower");

		public int m_queuedSpentMana => method_2<int>("m_queuedSpentMana");

		public int m_usedTempMana => method_2<int>("m_usedTempMana");

		public int m_realtimeTempMana => method_2<int>("m_realtimeTempMana");

		public bool m_realTimeComboActive => method_2<bool>("m_realTimeComboActive");

		public bool m_realTimeSpellsCostHealth => method_2<bool>("m_realTimeSpellsCostHealth");

		public MedalInfoTranslator m_medalInfo => method_3<MedalInfoTranslator>("m_medalInfo");

		public uint m_arenaWins => method_2<uint>("m_arenaWins");

		public uint m_arenaLoss => method_2<uint>("m_arenaLoss");

		public uint m_tavernBrawlWins => method_2<uint>("m_tavernBrawlWins");

		public uint m_tavernBrawlLoss => method_2<uint>("m_tavernBrawlLoss");

		public bool m_concedeEmotePlayed => method_2<bool>("m_concedeEmotePlayed");

		public TAG_PLAYSTATE m_preGameOverPlayState => method_2<TAG_PLAYSTATE>("m_preGameOverPlayState");

		public bool m_hasSeenMalchezaarSpell => method_2<bool>("m_hasSeenMalchezaarSpell");

		public Player(IntPtr address, string className)
			: base(address, className)
		{
		}

		public Player(IntPtr address)
			: this(address, "Player")
		{
		}

		public static Side GetOppositePlayerSide(Side side)
		{
			return MonoClass.smethod_14<Side>(TritonHs.MainAssemblyPath, "", "Player", "GetOppositePlayerSide", new object[1] { side });
		}

		public void InitPlayer(Network.HistCreateGame.PlayerData netPlayer)
		{
			method_8("InitPlayer", netPlayer);
		}

		public new bool HasValidDisplayName()
		{
			return method_11<bool>("HasValidDisplayName", Array.Empty<object>());
		}

		public new string GetName()
		{
			return method_13("GetName");
		}

		public MedalInfoTranslator GetRank()
		{
			return method_14<MedalInfoTranslator>("GetRank", Array.Empty<object>());
		}

		public new string GetDebugName()
		{
			return method_13("GetDebugName");
		}

		public void SetName(string name)
		{
			method_8("SetName", name);
		}

		public void RequestPlayerPresence()
		{
			method_8("RequestPlayerPresence");
		}

		public bool IsLocalUser()
		{
			return method_11<bool>("IsLocalUser", Array.Empty<object>());
		}

		public void SetLocalUser(bool local)
		{
			method_8("SetLocalUser", local);
		}

		public bool IsAI()
		{
			return method_11<bool>("IsAI", Array.Empty<object>());
		}

		public bool IsHuman()
		{
			return method_11<bool>("IsHuman", Array.Empty<object>());
		}

		public bool IsBnetPlayer()
		{
			return method_11<bool>("IsBnetPlayer", Array.Empty<object>());
		}

		public bool IsGuestPlayer()
		{
			return method_11<bool>("IsGuestPlayer", Array.Empty<object>());
		}

		public Side GetSide()
		{
			return method_11<Side>("GetSide", Array.Empty<object>());
		}

		public bool IsFriendlySide()
		{
			return method_11<bool>("IsFriendlySide", Array.Empty<object>());
		}

		public bool IsOpposingSide()
		{
			return method_11<bool>("IsOpposingSide", Array.Empty<object>());
		}

		public bool IsRevealed()
		{
			return method_11<bool>("IsRevealed", Array.Empty<object>());
		}

		public void SetSide(Side side)
		{
			method_8("SetSide", side);
		}

		public int GetCardBackId()
		{
			return method_11<int>("GetCardBackId", Array.Empty<object>());
		}

		public void SetCardBackId(int id)
		{
			method_8("SetCardBackId", id);
		}

		public int GetPlayerId()
		{
			return method_11<int>("GetPlayerId", Array.Empty<object>());
		}

		public void SetPlayerId(int playerId)
		{
			method_8("SetPlayerId", playerId);
		}

		public List<string> GetSecretDefinitions()
		{
			return method_14<Class272>("GetSecretDefinitions", Array.Empty<object>())?.method_25();
		}

		public List<string> GetQuestDefinitions()
		{
			return method_14<Class272>("GetQuestDefinitions", Array.Empty<object>())?.method_25();
		}

		public bool IsCurrentPlayer()
		{
			return method_11<bool>("IsCurrentPlayer", Array.Empty<object>());
		}

		public bool IsComboActive()
		{
			return method_11<bool>("IsComboActive", Array.Empty<object>());
		}

		public bool IsRealTimeComboActive()
		{
			return method_11<bool>("IsRealTimeComboActive", Array.Empty<object>());
		}

		public void SetRealTimeComboActive(int tagValue)
		{
			method_9("SetRealTimeComboActive", new Class276.Enum20[1] { Class276.Enum20.I4 }, tagValue);
		}

		public void SetRealTimeComboActive(bool active)
		{
			method_9("SetRealTimeComboActive", new Class276.Enum20[1] { Class276.Enum20.Boolean }, active);
		}

		public void SetRealTimeSpellsCostHealth(int value)
		{
			method_8("SetRealTimeSpellsCostHealth", value);
		}

		public bool GetRealTimeSpellsCostHealth()
		{
			return method_11<bool>("GetRealTimeSpellsCostHealth", Array.Empty<object>());
		}

		public int GetNumAvailableResources()
		{
			return method_11<int>("GetNumAvailableResources", Array.Empty<object>());
		}

		public bool HasWeapon()
		{
			return method_11<bool>("HasWeapon", Array.Empty<object>());
		}

		public void SetHero(Entity hero)
		{
			method_8("SetHero", hero);
		}

		public Entity GetStartingHero()
		{
			return method_14<Entity>("GetStartingHero", Array.Empty<object>());
		}

		public new Entity GetHero()
		{
			return method_14<Entity>("GetHero", Array.Empty<object>());
		}

		public EntityDef GetHeroEntityDef()
		{
			return method_14<EntityDef>("GetHeroEntityDef", Array.Empty<object>());
		}

		public new Card GetHeroCard()
		{
			return method_14<Card>("GetHeroCard", Array.Empty<object>());
		}

		public void SetHeroPower(Entity heroPower)
		{
			method_8("SetHeroPower", heroPower);
		}

		public new Entity GetHeroPower()
		{
			return method_14<Entity>("GetHeroPower", Array.Empty<object>());
		}

		public new Card GetHeroPowerCard()
		{
			return method_14<Card>("GetHeroPowerCard", Array.Empty<object>());
		}

		public bool IsHeroPowerAffectedByBonusDamage()
		{
			return method_11<bool>("IsHeroPowerAffectedByBonusDamage", Array.Empty<object>());
		}

		public new Card GetWeaponCard()
		{
			return method_14<Card>("GetWeaponCard", Array.Empty<object>());
		}

		public ZoneHand GetHandZone()
		{
			return method_14<ZoneHand>("GetHandZone", Array.Empty<object>());
		}

		public ZonePlay GetBattlefieldZone()
		{
			return method_14<ZonePlay>("GetBattlefieldZone", Array.Empty<object>());
		}

		public ZoneDeck GetDeckZone()
		{
			return method_14<ZoneDeck>("GetDeckZone", Array.Empty<object>());
		}

		public ZoneGraveyard GetGraveyardZone()
		{
			return method_14<ZoneGraveyard>("GetGraveyardZone", Array.Empty<object>());
		}

		public ZoneSecret GetSecretZone()
		{
			return method_14<ZoneSecret>("GetSecretZone", Array.Empty<object>());
		}

		public ZoneHero GetHeroZone()
		{
			return method_14<ZoneHero>("GetHeroZone", Array.Empty<object>());
		}

		public int GetNumDragonsInHand()
		{
			return method_11<int>("GetNumDragonsInHand", Array.Empty<object>());
		}

		public bool HasReadyAttackers()
		{
			return method_11<bool>("HasReadyAttackers", Array.Empty<object>());
		}

		public bool HasATauntMinion()
		{
			return method_11<bool>("HasATauntMinion", Array.Empty<object>());
		}

		public uint GetArenaWins()
		{
			return method_11<uint>("GetArenaWins", Array.Empty<object>());
		}

		public uint GetArenaLosses()
		{
			return method_11<uint>("GetArenaLosses", Array.Empty<object>());
		}

		public uint GetTavernBrawlWins()
		{
			return method_11<uint>("GetTavernBrawlWins", Array.Empty<object>());
		}

		public uint GetTavernBrawlLosses()
		{
			return method_11<uint>("GetTavernBrawlLosses", Array.Empty<object>());
		}

		public void PlayConcedeEmote()
		{
			method_8("PlayConcedeEmote");
		}

		public BnetPlayer GetBnetPlayer()
		{
			return method_14<BnetPlayer>("GetBnetPlayer", Array.Empty<object>());
		}

		public bool IsDisplayable()
		{
			return method_11<bool>("IsDisplayable", Array.Empty<object>());
		}

		public void WipeZzzs()
		{
			method_8("WipeZzzs");
		}

		public TAG_PLAYSTATE GetPreGameOverPlayState()
		{
			return method_11<TAG_PLAYSTATE>("GetPreGameOverPlayState", Array.Empty<object>());
		}

		public bool HasSeenMalchezaarSpell()
		{
			return method_11<bool>("HasSeenMalchezaarSpell", Array.Empty<object>());
		}

		public void SetHasSeenMalchezaarSpell(bool hasSeen)
		{
			method_8("SetHasSeenMalchezaarSpell", hasSeen);
		}

		public void AddManaCrystal(int numCrystals, bool isTurnStart)
		{
			method_9("AddManaCrystal", new Class276.Enum20[2]
			{
				Class276.Enum20.I4,
				Class276.Enum20.Boolean
			}, numCrystals, isTurnStart);
		}

		public void AddManaCrystal(int numCrystals)
		{
			method_9("AddManaCrystal", new Class276.Enum20[1] { Class276.Enum20.I4 }, numCrystals);
		}

		public void DestroyManaCrystal(int numCrystals)
		{
			method_8("DestroyManaCrystal", numCrystals);
		}

		public void AddTempManaCrystal(int numCrystals)
		{
			method_8("AddTempManaCrystal", numCrystals);
		}

		public void DestroyTempManaCrystal(int numCrystals)
		{
			method_8("DestroyTempManaCrystal", numCrystals);
		}

		public void SpendManaCrystal(int numCrystals)
		{
			method_8("SpendManaCrystal", numCrystals);
		}

		public void ReadyManaCrystal(int numCrystals)
		{
			method_8("ReadyManaCrystal", numCrystals);
		}

		public void HandleSameTurnOverloadChanged(int crystalsChanged)
		{
			method_8("HandleSameTurnOverloadChanged", crystalsChanged);
		}

		public void UnlockCrystals(int numCrystals)
		{
			method_8("UnlockCrystals", numCrystals);
		}

		public void CancelAllProposedMana(Entity entity)
		{
			method_8("CancelAllProposedMana", entity);
		}

		public void ProposeManaCrystalUsage(Entity entity)
		{
			method_8("ProposeManaCrystalUsage", entity);
		}

		public void UpdateManaCounter()
		{
			method_8("UpdateManaCounter");
		}

		public void NotifyOfSpentMana(int spentMana)
		{
			method_8("NotifyOfSpentMana", spentMana);
		}

		public void NotifyOfUsedTempMana(int usedMana)
		{
			method_8("NotifyOfUsedTempMana", usedMana);
		}

		public int GetQueuedUsedTempMana()
		{
			return method_11<int>("GetQueuedUsedTempMana", Array.Empty<object>());
		}

		public int GetQueuedSpentMana()
		{
			return method_11<int>("GetQueuedSpentMana", Array.Empty<object>());
		}

		public void SetRealTimeTempMana(int tempMana)
		{
			method_8("SetRealTimeTempMana", tempMana);
		}

		public int GetRealTimeTempMana()
		{
			return method_11<int>("GetRealTimeTempMana", Array.Empty<object>());
		}

		public void OnBoardLoaded()
		{
			method_8("OnBoardLoaded");
		}

		public new void OnRealTimeTagChanged(Network.HistTagChange change)
		{
			method_8("OnRealTimeTagChanged", change);
		}

		public new void OnTagsChanged(TagDeltaList changeList)
		{
			method_8("OnTagsChanged", changeList);
		}

		public new void OnTagChanged(TagDelta change)
		{
			method_8("OnTagChanged", change);
		}

		public void OnFriendlyPlayerTagChanged(TagDelta change)
		{
			method_8("OnFriendlyPlayerTagChanged", change);
		}

		public void OnOpposingPlayerTagChanged(TagDelta change)
		{
			method_8("OnOpposingPlayerTagChanged", change);
		}

		public void UpdateName()
		{
			method_8("UpdateName");
		}

		public bool ShouldUseHeroName()
		{
			return method_11<bool>("ShouldUseHeroName", Array.Empty<object>());
		}

		public void UpdateNameWithHeroName()
		{
			method_8("UpdateNameWithHeroName");
		}

		public bool ShouldUseBogusRank()
		{
			return method_11<bool>("ShouldUseBogusRank", Array.Empty<object>());
		}

		public void UpdateRank()
		{
			method_8("UpdateRank");
		}

		public void UpdateDisplayInfo()
		{
			method_8("UpdateDisplayInfo");
		}

		public void UpdateSessionRecord()
		{
			method_8("UpdateSessionRecord");
		}

		public void OnBnetPlayersChanged(BnetPlayerChangelist changelist, object userData)
		{
			method_8("OnBnetPlayersChanged", changelist, userData);
		}

		public void UpdateLocal()
		{
			method_8("UpdateLocal");
		}

		public void UpdateSide()
		{
			method_8("UpdateSide");
		}

		public void AssignPlayerBoardObjects()
		{
			method_8("AssignPlayerBoardObjects");
		}

		public void InitManaCrystalMgr()
		{
			method_8("InitManaCrystalMgr");
		}

		public void OnTurnChanged(int oldTurn, int newTurn, object userData)
		{
			method_8("OnTurnChanged", oldTurn, newTurn, userData);
		}

		public void OnFriendlyOptionsReceived(object userData)
		{
			method_8("OnFriendlyOptionsReceived", userData);
		}

		public void OnFriendlyOptionsSent(Network.Options.Option option, object userData)
		{
			method_8("OnFriendlyOptionsSent", option, userData);
		}

		public void OnFriendlyTurnStarted(object userData)
		{
			method_8("OnFriendlyTurnStarted", userData);
		}

		public void ToggleActorSpellOnCard(Card card, TagDelta change, SpellType spellType)
		{
			method_8("ToggleActorSpellOnCard", card, change, spellType);
		}

		public void UpdateHandCardPowersText(bool onlySpells)
		{
			method_8("UpdateHandCardPowersText", onlySpells);
		}

		public void UpdateSpellsCostHealth(TagDelta change)
		{
			method_8("UpdateSpellsCostHealth", change);
		}

		public void UpdateChooseBoth()
		{
			method_9("UpdateChooseBoth", new Class276.Enum20[0]);
		}

		public void UpdateChooseBoth(Card card)
		{
			method_9("UpdateChooseBoth", new Class276.Enum20[1] { Class276.Enum20.Class }, card);
		}
	}
}
